// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.product.sub;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.ProductSub;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(ProductSub.class)
@Setter
@Getter
public class ProductSubSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "ProductSub".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("productId", "p");
    map.put("subId", "p2");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 所属产品
   */
  private Long productId;

  /**
   * 所属产品 比较(eq)
   */
  private Long productIdEq;
  /**
   * 所属产品 比较(neq)
   */
  private Long productIdNeq;
  /**
   * 所属产品 比较(gt)
   */
  private Long productIdGt;
  /**
   * 所属产品 比较(gte)
   */
  private Long productIdGte;
  /**
   * 所属产品 比较(lt)
   */
  private Long productIdLt;
  /**
   * 所属产品 比较(lte)
   */
  private Long productIdLte;
  /**
   * 所属产品 比较(contains)
   */
  private Long productIdContains;
  /**
   * 所属产品 比较(notcontains)
   */
  private Long productIdNotcontains;
  /**
   * 所属产品 比较(startswith)
   */
  private Long productIdStartswith;
  /**
   * 所属产品 比较(endswith)
   */
  private Long productIdEndswith;
  /**
   * 所属产品 比较(isnull)
   */
  private Boolean productIdIsnull;
  /**
   * 所属产品 比较(isnotnull)
   */
  private Boolean productIdIsnotnull;
  /**
   * 所属产品的品名 比较(eq)
   */
  private String productIdNameEq;
  /**
   * 所属产品的品名 比较(neq)
   */
  private String productIdNameNeq;
  /**
   * 所属产品的品名 比较(gt)
   */
  private String productIdNameGt;
  /**
   * 所属产品的品名 比较(gte)
   */
  private String productIdNameGte;
  /**
   * 所属产品的品名 比较(lt)
   */
  private String productIdNameLt;
  /**
   * 所属产品的品名 比较(lte)
   */
  private String productIdNameLte;
  /**
   * 所属产品的品名 比较(contains)
   */
  private String productIdNameContains;
  /**
   * 所属产品的品名 比较(notcontains)
   */
  private String productIdNameNotcontains;
  /**
   * 所属产品的品名 比较(startswith)
   */
  private String productIdNameStartswith;
  /**
   * 所属产品的品名 比较(endswith)
   */
  private String productIdNameEndswith;
  /**
   * 所属产品的品名 比较(isnull)
   */
  private Boolean productIdNameIsnull;
  /**
   * 所属产品的品名 比较(isnotnull)
   */
  private Boolean productIdNameIsnotnull;

  /**
   * 所属产品(范围搜索)
   */
  private List<Long> productIdInList;

  /**
   * 是否有 图片
   */
  private Boolean picUrl;

  /**
   * 产品
   */
  private Long subId;

  /**
   * 产品 比较(eq)
   */
  private Long subIdEq;
  /**
   * 产品 比较(neq)
   */
  private Long subIdNeq;
  /**
   * 产品 比较(gt)
   */
  private Long subIdGt;
  /**
   * 产品 比较(gte)
   */
  private Long subIdGte;
  /**
   * 产品 比较(lt)
   */
  private Long subIdLt;
  /**
   * 产品 比较(lte)
   */
  private Long subIdLte;
  /**
   * 产品 比较(contains)
   */
  private Long subIdContains;
  /**
   * 产品 比较(notcontains)
   */
  private Long subIdNotcontains;
  /**
   * 产品 比较(startswith)
   */
  private Long subIdStartswith;
  /**
   * 产品 比较(endswith)
   */
  private Long subIdEndswith;
  /**
   * 产品 比较(isnull)
   */
  private Boolean subIdIsnull;
  /**
   * 产品 比较(isnotnull)
   */
  private Boolean subIdIsnotnull;
  /**
   * 产品的品名 比较(eq)
   */
  private String subIdNameEq;
  /**
   * 产品的品名 比较(neq)
   */
  private String subIdNameNeq;
  /**
   * 产品的品名 比较(gt)
   */
  private String subIdNameGt;
  /**
   * 产品的品名 比较(gte)
   */
  private String subIdNameGte;
  /**
   * 产品的品名 比较(lt)
   */
  private String subIdNameLt;
  /**
   * 产品的品名 比较(lte)
   */
  private String subIdNameLte;
  /**
   * 产品的品名 比较(contains)
   */
  private String subIdNameContains;
  /**
   * 产品的品名 比较(notcontains)
   */
  private String subIdNameNotcontains;
  /**
   * 产品的品名 比较(startswith)
   */
  private String subIdNameStartswith;
  /**
   * 产品的品名 比较(endswith)
   */
  private String subIdNameEndswith;
  /**
   * 产品的品名 比较(isnull)
   */
  private Boolean subIdNameIsnull;
  /**
   * 产品的品名 比较(isnotnull)
   */
  private Boolean subIdNameIsnotnull;

  /**
   * 产品(范围搜索)
   */
  private List<Long> subIdInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 型号(模糊搜索)
   */
  private String model;

  /**
   * 型号 比较(eq)
   */
  private String modelEq;
  /**
   * 型号 比较(neq)
   */
  private String modelNeq;
  /**
   * 型号 比较(gt)
   */
  private String modelGt;
  /**
   * 型号 比较(gte)
   */
  private String modelGte;
  /**
   * 型号 比较(lt)
   */
  private String modelLt;
  /**
   * 型号 比较(lte)
   */
  private String modelLte;
  /**
   * 型号 比较(contains)
   */
  private String modelContains;
  /**
   * 型号 比较(notcontains)
   */
  private String modelNotcontains;
  /**
   * 型号 比较(startswith)
   */
  private String modelStartswith;
  /**
   * 型号 比较(endswith)
   */
  private String modelEndswith;
  /**
   * 型号 比较(isnull)
   */
  private Boolean modelIsnull;
  /**
   * 型号 比较(isnotnull)
   */
  private Boolean modelIsnotnull;

  /**
   * 型号(精确搜索)
   */
  private List<String> modelInList;

  /**
   * 单位(模糊搜索)
   */
  private String unit;

  /**
   * 单位 比较(eq)
   */
  private String unitEq;
  /**
   * 单位 比较(neq)
   */
  private String unitNeq;
  /**
   * 单位 比较(gt)
   */
  private String unitGt;
  /**
   * 单位 比较(gte)
   */
  private String unitGte;
  /**
   * 单位 比较(lt)
   */
  private String unitLt;
  /**
   * 单位 比较(lte)
   */
  private String unitLte;
  /**
   * 单位 比较(contains)
   */
  private String unitContains;
  /**
   * 单位 比较(notcontains)
   */
  private String unitNotcontains;
  /**
   * 单位 比较(startswith)
   */
  private String unitStartswith;
  /**
   * 单位 比较(endswith)
   */
  private String unitEndswith;
  /**
   * 单位 比较(isnull)
   */
  private Boolean unitIsnull;
  /**
   * 单位 比较(isnotnull)
   */
  private Boolean unitIsnotnull;

  /**
   * 单位(精确搜索)
   */
  private List<String> unitInList;

  /**
   * 采购交期
   */
  private Integer purchasingDeliveryTime;

  /**
   * 最小采购交期
   */
  private Integer purchasingDeliveryTimeMin;

  /**
   * 最大采购交期
   */
  private Integer purchasingDeliveryTimeMax;

  /**
   * 采购交期 比较(eq)
   */
  private Integer purchasingDeliveryTimeEq;
  /**
   * 采购交期 比较(neq)
   */
  private Integer purchasingDeliveryTimeNeq;
  /**
   * 采购交期 比较(gt)
   */
  private Integer purchasingDeliveryTimeGt;
  /**
   * 采购交期 比较(gte)
   */
  private Integer purchasingDeliveryTimeGte;
  /**
   * 采购交期 比较(lt)
   */
  private Integer purchasingDeliveryTimeLt;
  /**
   * 采购交期 比较(lte)
   */
  private Integer purchasingDeliveryTimeLte;
  /**
   * 采购交期 比较(contains)
   */
  private Integer purchasingDeliveryTimeContains;
  /**
   * 采购交期 比较(notcontains)
   */
  private Integer purchasingDeliveryTimeNotcontains;
  /**
   * 采购交期 比较(startswith)
   */
  private Integer purchasingDeliveryTimeStartswith;
  /**
   * 采购交期 比较(endswith)
   */
  private Integer purchasingDeliveryTimeEndswith;
  /**
   * 采购交期 比较(isnull)
   */
  private Boolean purchasingDeliveryTimeIsnull;
  /**
   * 采购交期 比较(isnotnull)
   */
  private Boolean purchasingDeliveryTimeIsnotnull;

  /**
   * 采购成本
   */
  private java.math.BigDecimal procurementCost;

  /**
   * 最小采购成本
   */
  private java.math.BigDecimal procurementCostMin;

  /**
   * 最大采购成本
   */
  private java.math.BigDecimal procurementCostMax;

  /**
   * 采购成本 比较(eq)
   */
  private java.math.BigDecimal procurementCostEq;
  /**
   * 采购成本 比较(neq)
   */
  private java.math.BigDecimal procurementCostNeq;
  /**
   * 采购成本 比较(gt)
   */
  private java.math.BigDecimal procurementCostGt;
  /**
   * 采购成本 比较(gte)
   */
  private java.math.BigDecimal procurementCostGte;
  /**
   * 采购成本 比较(lt)
   */
  private java.math.BigDecimal procurementCostLt;
  /**
   * 采购成本 比较(lte)
   */
  private java.math.BigDecimal procurementCostLte;
  /**
   * 采购成本 比较(contains)
   */
  private java.math.BigDecimal procurementCostContains;
  /**
   * 采购成本 比较(notcontains)
   */
  private java.math.BigDecimal procurementCostNotcontains;
  /**
   * 采购成本 比较(startswith)
   */
  private java.math.BigDecimal procurementCostStartswith;
  /**
   * 采购成本 比较(endswith)
   */
  private java.math.BigDecimal procurementCostEndswith;
  /**
   * 采购成本 比较(isnull)
   */
  private Boolean procurementCostIsnull;
  /**
   * 采购成本 比较(isnotnull)
   */
  private Boolean procurementCostIsnotnull;

  /**
   * 产品长度
   */
  private java.math.BigDecimal productLength;

  /**
   * 最小产品长度
   */
  private java.math.BigDecimal productLengthMin;

  /**
   * 最大产品长度
   */
  private java.math.BigDecimal productLengthMax;

  /**
   * 产品长度 比较(eq)
   */
  private java.math.BigDecimal productLengthEq;
  /**
   * 产品长度 比较(neq)
   */
  private java.math.BigDecimal productLengthNeq;
  /**
   * 产品长度 比较(gt)
   */
  private java.math.BigDecimal productLengthGt;
  /**
   * 产品长度 比较(gte)
   */
  private java.math.BigDecimal productLengthGte;
  /**
   * 产品长度 比较(lt)
   */
  private java.math.BigDecimal productLengthLt;
  /**
   * 产品长度 比较(lte)
   */
  private java.math.BigDecimal productLengthLte;
  /**
   * 产品长度 比较(contains)
   */
  private java.math.BigDecimal productLengthContains;
  /**
   * 产品长度 比较(notcontains)
   */
  private java.math.BigDecimal productLengthNotcontains;
  /**
   * 产品长度 比较(startswith)
   */
  private java.math.BigDecimal productLengthStartswith;
  /**
   * 产品长度 比较(endswith)
   */
  private java.math.BigDecimal productLengthEndswith;
  /**
   * 产品长度 比较(isnull)
   */
  private Boolean productLengthIsnull;
  /**
   * 产品长度 比较(isnotnull)
   */
  private Boolean productLengthIsnotnull;

  /**
   * 产品宽度
   */
  private java.math.BigDecimal productWidth;

  /**
   * 最小产品宽度
   */
  private java.math.BigDecimal productWidthMin;

  /**
   * 最大产品宽度
   */
  private java.math.BigDecimal productWidthMax;

  /**
   * 产品宽度 比较(eq)
   */
  private java.math.BigDecimal productWidthEq;
  /**
   * 产品宽度 比较(neq)
   */
  private java.math.BigDecimal productWidthNeq;
  /**
   * 产品宽度 比较(gt)
   */
  private java.math.BigDecimal productWidthGt;
  /**
   * 产品宽度 比较(gte)
   */
  private java.math.BigDecimal productWidthGte;
  /**
   * 产品宽度 比较(lt)
   */
  private java.math.BigDecimal productWidthLt;
  /**
   * 产品宽度 比较(lte)
   */
  private java.math.BigDecimal productWidthLte;
  /**
   * 产品宽度 比较(contains)
   */
  private java.math.BigDecimal productWidthContains;
  /**
   * 产品宽度 比较(notcontains)
   */
  private java.math.BigDecimal productWidthNotcontains;
  /**
   * 产品宽度 比较(startswith)
   */
  private java.math.BigDecimal productWidthStartswith;
  /**
   * 产品宽度 比较(endswith)
   */
  private java.math.BigDecimal productWidthEndswith;
  /**
   * 产品宽度 比较(isnull)
   */
  private Boolean productWidthIsnull;
  /**
   * 产品宽度 比较(isnotnull)
   */
  private Boolean productWidthIsnotnull;

  /**
   * 产品高度
   */
  private java.math.BigDecimal productHeight;

  /**
   * 最小产品高度
   */
  private java.math.BigDecimal productHeightMin;

  /**
   * 最大产品高度
   */
  private java.math.BigDecimal productHeightMax;

  /**
   * 产品高度 比较(eq)
   */
  private java.math.BigDecimal productHeightEq;
  /**
   * 产品高度 比较(neq)
   */
  private java.math.BigDecimal productHeightNeq;
  /**
   * 产品高度 比较(gt)
   */
  private java.math.BigDecimal productHeightGt;
  /**
   * 产品高度 比较(gte)
   */
  private java.math.BigDecimal productHeightGte;
  /**
   * 产品高度 比较(lt)
   */
  private java.math.BigDecimal productHeightLt;
  /**
   * 产品高度 比较(lte)
   */
  private java.math.BigDecimal productHeightLte;
  /**
   * 产品高度 比较(contains)
   */
  private java.math.BigDecimal productHeightContains;
  /**
   * 产品高度 比较(notcontains)
   */
  private java.math.BigDecimal productHeightNotcontains;
  /**
   * 产品高度 比较(startswith)
   */
  private java.math.BigDecimal productHeightStartswith;
  /**
   * 产品高度 比较(endswith)
   */
  private java.math.BigDecimal productHeightEndswith;
  /**
   * 产品高度 比较(isnull)
   */
  private Boolean productHeightIsnull;
  /**
   * 产品高度 比较(isnotnull)
   */
  private Boolean productHeightIsnotnull;

  /**
   * 产品净重
   */
  private java.math.BigDecimal productNet;

  /**
   * 最小产品净重
   */
  private java.math.BigDecimal productNetMin;

  /**
   * 最大产品净重
   */
  private java.math.BigDecimal productNetMax;

  /**
   * 产品净重 比较(eq)
   */
  private java.math.BigDecimal productNetEq;
  /**
   * 产品净重 比较(neq)
   */
  private java.math.BigDecimal productNetNeq;
  /**
   * 产品净重 比较(gt)
   */
  private java.math.BigDecimal productNetGt;
  /**
   * 产品净重 比较(gte)
   */
  private java.math.BigDecimal productNetGte;
  /**
   * 产品净重 比较(lt)
   */
  private java.math.BigDecimal productNetLt;
  /**
   * 产品净重 比较(lte)
   */
  private java.math.BigDecimal productNetLte;
  /**
   * 产品净重 比较(contains)
   */
  private java.math.BigDecimal productNetContains;
  /**
   * 产品净重 比较(notcontains)
   */
  private java.math.BigDecimal productNetNotcontains;
  /**
   * 产品净重 比较(startswith)
   */
  private java.math.BigDecimal productNetStartswith;
  /**
   * 产品净重 比较(endswith)
   */
  private java.math.BigDecimal productNetEndswith;
  /**
   * 产品净重 比较(isnull)
   */
  private Boolean productNetIsnull;
  /**
   * 产品净重 比较(isnotnull)
   */
  private Boolean productNetIsnotnull;

  /**
   * 单品毛重
   */
  private java.math.BigDecimal productGross;

  /**
   * 最小单品毛重
   */
  private java.math.BigDecimal productGrossMin;

  /**
   * 最大单品毛重
   */
  private java.math.BigDecimal productGrossMax;

  /**
   * 单品毛重 比较(eq)
   */
  private java.math.BigDecimal productGrossEq;
  /**
   * 单品毛重 比较(neq)
   */
  private java.math.BigDecimal productGrossNeq;
  /**
   * 单品毛重 比较(gt)
   */
  private java.math.BigDecimal productGrossGt;
  /**
   * 单品毛重 比较(gte)
   */
  private java.math.BigDecimal productGrossGte;
  /**
   * 单品毛重 比较(lt)
   */
  private java.math.BigDecimal productGrossLt;
  /**
   * 单品毛重 比较(lte)
   */
  private java.math.BigDecimal productGrossLte;
  /**
   * 单品毛重 比较(contains)
   */
  private java.math.BigDecimal productGrossContains;
  /**
   * 单品毛重 比较(notcontains)
   */
  private java.math.BigDecimal productGrossNotcontains;
  /**
   * 单品毛重 比较(startswith)
   */
  private java.math.BigDecimal productGrossStartswith;
  /**
   * 单品毛重 比较(endswith)
   */
  private java.math.BigDecimal productGrossEndswith;
  /**
   * 单品毛重 比较(isnull)
   */
  private Boolean productGrossIsnull;
  /**
   * 单品毛重 比较(isnotnull)
   */
  private Boolean productGrossIsnotnull;

  /**
   * 产品材质(模糊搜索)
   */
  private String material;

  /**
   * 产品材质 比较(eq)
   */
  private String materialEq;
  /**
   * 产品材质 比较(neq)
   */
  private String materialNeq;
  /**
   * 产品材质 比较(gt)
   */
  private String materialGt;
  /**
   * 产品材质 比较(gte)
   */
  private String materialGte;
  /**
   * 产品材质 比较(lt)
   */
  private String materialLt;
  /**
   * 产品材质 比较(lte)
   */
  private String materialLte;
  /**
   * 产品材质 比较(contains)
   */
  private String materialContains;
  /**
   * 产品材质 比较(notcontains)
   */
  private String materialNotcontains;
  /**
   * 产品材质 比较(startswith)
   */
  private String materialStartswith;
  /**
   * 产品材质 比较(endswith)
   */
  private String materialEndswith;
  /**
   * 产品材质 比较(isnull)
   */
  private Boolean materialIsnull;
  /**
   * 产品材质 比较(isnotnull)
   */
  private Boolean materialIsnotnull;

  /**
   * 产品材质(精确搜索)
   */
  private List<String> materialInList;

  /**
   * 数量
   */
  private Long num;

  /**
   * 最小数量
   */
  private Long numMin;

  /**
   * 最大数量
   */
  private Long numMax;

  /**
   * 数量 比较(eq)
   */
  private Long numEq;
  /**
   * 数量 比较(neq)
   */
  private Long numNeq;
  /**
   * 数量 比较(gt)
   */
  private Long numGt;
  /**
   * 数量 比较(gte)
   */
  private Long numGte;
  /**
   * 数量 比较(lt)
   */
  private Long numLt;
  /**
   * 数量 比较(lte)
   */
  private Long numLte;
  /**
   * 数量 比较(contains)
   */
  private Long numContains;
  /**
   * 数量 比较(notcontains)
   */
  private Long numNotcontains;
  /**
   * 数量 比较(startswith)
   */
  private Long numStartswith;
  /**
   * 数量 比较(endswith)
   */
  private Long numEndswith;
  /**
   * 数量 比较(isnull)
   */
  private Boolean numIsnull;
  /**
   * 数量 比较(isnotnull)
   */
  private Boolean numIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
